home *** CD-ROM | disk | FTP | other *** search
/ Greenhouse Effect Detection Expriment / NASA Greenhouse Effect Detection Expriment 1992 - Disc 2.iso / software / dos / cdf22pc / src / tools / skt2cdf1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-04  |  71.6 KB  |  2,594 lines

  1. /******************************************************************************
  2. *
  3. *  NSSDC/CDF                        CDFskeleton.  Part 1 of 2.
  4. *
  5. *  Version 1.0, 4-Mar-92, ST Systems (STX)
  6. *
  7. *  Modification history:
  8. *
  9. *   V1.0   4-Mar-92, S Sudarsan       Original version.  This is a crunching
  10. *             J Love       together of all the separate files which
  11. *                   used to make up CDFskeleton.  Two source
  12. *                   files necessary for IBM PC compilation.
  13. *   
  14. ******************************************************************************/
  15.  
  16. #include "cdfdist.h"
  17.  
  18. #define SKT2CDF        /* For global/external variables. Only defined in one
  19.                of the source files for CDFskeleton. */
  20. #include "skt2cdf.h"
  21.  
  22. /******************************************************************************
  23. * Online instructions.
  24. ******************************************************************************/
  25.  
  26. static char *instructions[] = {
  27. #if defined(vms)
  28. "Usage:         $ CDFSKELETON [/CDF=<cdf-path>] [/[no]LOG] [/[no]DELETE]",
  29. "                             <skeleton-path>",
  30. #endif
  31. #if defined(unix)
  32. "Usage:         % cdfskeleton [-cdf <cdf-path>] [-[no]log] [-[no]delete]",
  33. "                             <skeleton-path>",
  34. #endif
  35. #if defined(__MSDOS__)
  36. "Usage:         > cdfskeleton [-cdf <cdf-path>] [-[no]log] [-[no]delete]",
  37. "                             <skeleton-path>",
  38. #endif
  39. "",
  40. "Purpose:       CDFskeleton produces a CDF from a skeleton table.", 
  41. "",
  42. "               A skeleton table is a text file which is read ",
  43. "               by the CDFskeleton program to build a skeleton CDF.",
  44. "",
  45. "Parameter(s):  <skeleton-path>",
  46. "                  The pathname of the skeleton table file (without its",
  47. "                  extension).  Required.",
  48. "",
  49. #if defined(vms)
  50. "Qualifier(s):  /CDF=<cdf-path>",
  51. #endif
  52. #if defined(unix) | defined(__MSDOS__)
  53. "Qualifier(s):  -cdf cdf-path>",
  54. #endif
  55. "                  <cdf-path> is the pathname of the CDF that will be built",
  56. "                  (overriding the pathname in the skeleton table).  Optional.",
  57. "",
  58. #if defined(vms)
  59. "               /[no]LOG",
  60. #endif
  61. #if defined(unix) | defined(__MSDOS__)
  62. "               -[no]log",
  63. #endif
  64. "                  Specifies whether or not messages are displayed as the",
  65. "                  program executes.  The default is logging disabled.",
  66. "",
  67. #if defined(vms)
  68. "               /[no]DELETE",
  69. #endif
  70. #if defined(unix) | defined(__MSDOS__)
  71. "               -[no]delete",
  72. #endif
  73. "                  Specifies whether or not the CDF should be deleted if it",
  74. "                  already exists.  The default is not to delete the CDF.",
  75. "",
  76. #if defined(vms)
  77. "Example(s):    $ CDFSKELETON/NOLOG/DELETE SSCLIMATE",
  78. "               $ CDFSKELETON/CDF=SSCLIMATEX SSCLIMATE",
  79. #endif
  80. #if defined(unix)
  81. "Example(s):    % cdfskeleton -nolog -delete ssclimate",
  82. "               % cdfskeleton -cdf ../ssclimatex ssclimate",
  83. #endif
  84. #if defined(__MSDOS__)
  85. "Example(s):    > cdfskeleton -nolog -delete ssclim",
  86. "               > cdfskeleton -cdf ssclimx a:\\cdfs\\ssclim",
  87. #endif
  88. NULL };
  89.  
  90. /******************************************************************************
  91. * Main (CDFskeleton).
  92. ******************************************************************************/
  93.  
  94. #if defined(vms)
  95. main (argc, argv)
  96. #else
  97. void main (argc, argv)
  98. #endif
  99. int argc;
  100. char *argv[];
  101. {
  102.  
  103.    char stfname[64];
  104.    char openname[64];                        /* V1.1 */
  105.  
  106.    Boolean delete_if_exists;
  107.  
  108.    long count;
  109.    static char *validQuals[] = { "cdf*", "log", "nolog",
  110.                  "delete", "nodelete", NULL };
  111.    static int optRequired[] = { TRUE, FALSE, FALSE,
  112.                 FALSE, FALSE, 0 };
  113.    QOP *qop;
  114.  
  115.      switch (argc) {
  116.       case 1:
  117.         PageInst (instructions);
  118.         Exit;
  119.       default:
  120.     qop = Qop (argc, argv, validQuals, optRequired);
  121.     if (qop == NULL) ExitBAD;
  122.  
  123.     if (qop->Nparms < 1) {
  124.       printf ("Missing parameter\n");
  125.       ExitBAD;
  126.     }
  127.     else {
  128.       strcpy (stfname, qop->parms[0]);
  129.       strcpy (sname, qop->parms[0]);
  130.     }
  131.  
  132.     if (qop->qualEntered[0]) {
  133.       cdf_name = (char *) malloc (strlen(qop->qualOpt[0]) + 1);
  134.       strcpy (cdf_name, qop->qualOpt[0]);
  135.     }
  136.     else
  137.       cdf_name = NULL;
  138.  
  139.     count = 0;
  140.         if (qop->qualEntered[1]) count++;
  141.         if (qop->qualEntered[2]) count++;
  142.  
  143.         switch (count) {
  144.           case 0:
  145.             mLog = FALSE;
  146.         break;
  147.           case 1:
  148.         if (qop->qualEntered[1])
  149.           mLog = TRUE;
  150.         else
  151.           mLog = FALSE;
  152.         break;
  153.           default:
  154.         printf ("Conflicting qualifiers.\n");
  155.         ExitBAD;
  156.     }
  157.  
  158.     count = 0;
  159.         if (qop->qualEntered[3]) count++;
  160.         if (qop->qualEntered[4]) count++;
  161.  
  162.         switch (count) {
  163.           case 0:
  164.             delete_if_exists = FALSE;
  165.         break;
  166.           case 1:
  167.         if (qop->qualEntered[3])
  168.           delete_if_exists = TRUE;
  169.         else
  170.           delete_if_exists = FALSE;
  171.         break;
  172.           default:
  173.         printf ("Conflicting qualifiers.\n");
  174.         ExitBAD;
  175.     }
  176.      }
  177.  
  178.      strcpy (openname, stfname);                /* V1.1...*/
  179.      strcat (openname, ".skt");
  180.  
  181.      file_ptr = fopen (openname, "r");
  182.      if (file_ptr == NULL) {
  183.        strcpy (openname, stfname);
  184.        strcat (openname, ".skeleton_table");
  185.        file_ptr = fopen (openname, "r");
  186.        if (file_ptr == NULL) {
  187.          if (mLog) printf ("\nCDF  SKELETON TABLE NOT FOUND :%s", stfname);
  188.          ExitBAD;
  189.        }
  190.      }                                /* ...V1.1 */
  191.  
  192.       AnalyseHeader(delete_if_exists);                /* V1.1 */
  193.       if (mLog) fprintf(stdout,"\n Reading Global Attributes....\n");
  194.       AnalyseGlobalAttr();
  195.       if (mLog) fprintf(stdout,"\n Reading Variable Attributes....\n");
  196.       AnalyseVariableAttr();
  197.       if (mLog) fprintf(stdout,"\n Reading Variables....\n");
  198.       AnalyseVariables(); 
  199. Exit;
  200. }  /* end main */
  201.  
  202. /*------------------------------------------------------------------*/
  203. static void AnalyseHeader(delete_if_exists)            /* V1.1 */
  204. Boolean delete_if_exists;
  205. {
  206.  
  207.      long hdr_flag = 0, len, index, o_flag;
  208.  
  209.      char *buff, dummy[10], 
  210.           *encoding, *majority, *ptr;
  211.  
  212.       while(hdr_flag != 1)/* to first seek the "#header" */
  213.         {
  214.  
  215.           if(fgets(obuffer, 134, file_ptr)==NULL)
  216.            {
  217.             if (mLog) fprintf(stderr,"\nINCORRECT HEADER SPECIFICATION\n");
  218.             ExitBAD; 
  219.            }
  220.            
  221.  
  222.            len = strlen(obuffer);/* to insert in the end */
  223.            
  224.            *(obuffer + (len - 1)) = '\0';
  225.            
  226.            buff = TrimBlanks(obuffer);/* get past white spaces before 
  227.                                         the header */
  228.  
  229.            switch(*buff)
  230.             {
  231.               case '\0':
  232.                 break;                
  233.               case '!':
  234.                 break;
  235.               case '#':
  236.                {
  237.                  if(strncmp(buff,"#header",7)==0)
  238.                  {
  239.                    buff = buff + strlen("#header");
  240.                                       /* get past the above */                
  241.                  switch(*buff)
  242.                  {
  243.                    case '\0':
  244.                      hdr_flag++;
  245.                     break;
  246.                    case '!':
  247.                      hdr_flag++;
  248.                     break;
  249.                    default:
  250.                     {
  251.              if (mLog) {
  252.                        fprintf(stderr, "\nINCORRECT HEADER SPECIFICATION\n");
  253.                        fprintf(stderr,"%s\n", obuffer);
  254.              }
  255.                      ExitBAD;
  256.                     }
  257.                     break;
  258.                  }/* end switch */
  259.                 }/* end if*/
  260.                 else if(strncmp(buff,"#end",4) == 0)
  261.                  {
  262.                    /*CloseCDF();*/
  263.                    buff = buff + 4;
  264.                    
  265.                    switch(*buff)
  266.                    {
  267.                      case '!':
  268.                      break;
  269.                      case '\0':
  270.                      break;
  271.                      default:
  272.                      {
  273.               if (mLog) {
  274.                         fprintf(stderr, "\nINCORRECT HEADER SPECIFICATION\n");
  275.                         fprintf(stderr,"%s\n", obuffer);
  276.               }
  277.                       ExitBAD;
  278.                      }
  279.                      break;
  280.                    }/* end switch */
  281.  
  282.                   ExitBAD;/* not closing the CDF because not created it */
  283.  
  284.                  }/* end else */
  285.                 else/* not #header or #end */
  286.                  {
  287.           if (mLog) {
  288.                     fprintf(stderr, "\nINCORRECT HEADER SPECIFICATION\n");
  289.                     fprintf(stderr,"%s\n", obuffer);
  290.           }
  291.                   ExitBAD;
  292.                  }/* end else */
  293.                }/* end case # */        
  294.               break;
  295.               default:
  296.                 {
  297.          if (mLog) {
  298.                    fprintf(stderr, "\nINCORRECT HEADER SPECIFICATION\n");
  299.                    fprintf(stderr,"%s\n", obuffer);
  300.          }
  301.                  ExitBAD;
  302.                  }
  303.               break;
  304.             }/* end switch */
  305.         } /* end while */
  306.  
  307.        hdr_flag = 0;/* reinitialise */
  308.  
  309.        while(hdr_flag != 1)/* for output file name */
  310.         {
  311.            if(fgets(obuffer, 134, file_ptr)==NULL)
  312.            {
  313.         if (mLog) {
  314.               fprintf(stderr,"\nINCORRECT HEADER SPECIFICATION\n");
  315.               fprintf(stderr,"%s\n", obuffer);
  316.         }
  317.             ExitBAD; 
  318.            }
  319.  
  320.            len = strlen(obuffer);
  321.  
  322.            *(obuffer + (len-1)) = '\0';
  323.  
  324.            buff = TrimBlanks(obuffer);
  325.  
  326.            switch(*buff)/* to look for output file name */
  327.             {
  328.               case '\0':
  329.                 break;                
  330.               case '!':
  331.                 break;
  332.               default :
  333.                {
  334.                  len = StringTraverse(buff);
  335.  
  336.                  if((strncmp(buff,"OUTPUT", 6) != 0)&&
  337.                     (strncmp(buff,"output", 6) != 0)&&
  338.                     (strncmp(buff, "cdf", 3) != 0)&&
  339.                     (strncmp(buff, "CDF", 3) != 0))
  340.                    {
  341.             if (mLog) {
  342.                       fprintf(stderr, 
  343.                           "\nINCORRECT OUTPUT FILE/CDF NAME SPECIFICATION\n");
  344.                       fprintf(stderr,"%s\n", obuffer);
  345.             }
  346.                      ExitBAD;
  347.                    }
  348.  
  349.  
  350.                  if((strncmp(buff,"OUTPUT", 6) == 0)||
  351.                  (strncmp(buff,"output", 6) == 0))
  352.                   o_flag = 1;
  353.                  else
  354.                   o_flag = 2; 
  355.                    
  356.               buff = buff + len;/* to get past output */
  357.  
  358.               buff  = TrimBlanks(buff); 
  359.  
  360.  
  361.              if((*buff == '\0')||(*buff == '!'))/* if it ends there */
  362.                 buff = ProcessWrapLines
  363.                       (file_ptr, obuffer,
  364.                            "Incorrect CDF/Output File Name Specification\n");
  365.               
  366.  
  367.            if(o_flag == 1)/* for output file */
  368.                {
  369.                  if((strncmp(buff,"file", 4) != 0)&&
  370.                     (strncmp(buff,"FILE", 4) != 0))
  371.                    {
  372.             if (mLog) {
  373.                       fprintf(stderr, 
  374.                           "\nINCORRECT CDF/OUTPUT FILE NAME SPECIFICATION\n");
  375.                       fprintf(stderr,"%s\n", obuffer);
  376.             }
  377.                      ExitBAD;
  378.                    }                 
  379.                      
  380.                  len = StringTraverse(buff);
  381.  
  382.                  buff = buff + len;/* to get past file */
  383.  
  384.                  buff = TrimBlanks(buff);
  385.  
  386.  
  387.                if((*buff == '\0')||(*buff == '!'))/* if it ends there */
  388.                 buff = ProcessWrapLines
  389.                       (file_ptr, obuffer,
  390.                         "Incorrect CDF/Output File Name Specification\n");
  391.  
  392.                }
  393.  
  394.                  if((strncmp(buff,"name", 4) == 0)&&
  395.                     (strncmp(buff,"NAME", 4) == 0))
  396.                    {
  397.              if (mLog) {
  398.                        fprintf(stderr, 
  399.                           "\nINCORRECT CDF/OUTPUT FILE NAME SPECIFICATION\n");
  400.                        fprintf(stderr,"%s\n", obuffer);
  401.              }
  402.                      ExitBAD;
  403.                    }
  404.  
  405.                  buff = buff + 4;/* get past the name */
  406.  
  407.                  buff = TrimBlanks(buff);
  408.  
  409.                  
  410.                if((*buff == '\0')||(*buff == '!'))/* if it ends there */
  411.                 buff = ProcessWrapLines
  412.                       (file_ptr, obuffer,
  413.             "Incorrect CDF/Output File Name Specification\n");
  414.  
  415.                  switch (*buff)
  416.                   {
  417.                     case ':':
  418.                       break;
  419.                     default:
  420.                       {
  421.               if (mLog) {
  422.                         fprintf(stderr, 
  423.                           "\nINCORRECT CDF/OUTPUT FILE NAME SPECIFICATION\n");
  424.                         fprintf(stderr,"%s\n", obuffer);
  425.               }
  426.                       ExitBAD;
  427.                       }
  428.                       break; 
  429.                    }/* end switch*/
  430.  
  431.                  buff++;/* to move past the : */
  432.  
  433.  
  434.                buff = TrimBlanks(buff);
  435.  
  436.                if((*buff == '\0')||(*buff == '!'))/* if it ends there */
  437.                 buff = ProcessWrapLines
  438.                       (file_ptr, obuffer,
  439.             "Incorrect CDF/Output File Name Specification\n");
  440.  
  441.                  
  442.                  len = StringTraverse(buff);/* to reach end of file name */ 
  443.  
  444.                if(cdf_name == NULL)                /* V1.1 */
  445.                 {         
  446.                  cdf_name = (char *) malloc(len + 1);
  447.                  strncpy(cdf_name, buff, len);
  448.                  *(cdf_name + len) = '\0';              
  449.                 }
  450.  
  451.                  if (mLog) printf("CDF name %s\n", cdf_name);
  452.  
  453.  
  454.                  buff = buff + len;/* move past the file name */
  455.  
  456.                  buff = TrimBlanks(buff);
  457.                  
  458.                  switch (*buff)
  459.                  {
  460.                    case '\0':
  461.                       hdr_flag++;
  462.                    break;
  463.                    case '!':
  464.                       hdr_flag++;
  465.                    break;
  466.                    default:/* unrecognizable char after file name */
  467.                    {
  468.              if (mLog) {
  469.                        fprintf(stderr, 
  470.                            "\nINCORRECT CDF/OUTPUT FILE NAME SPECIFICATION\n");
  471.                        fprintf(stderr,"%s\n", obuffer);
  472.              }
  473.                      ExitBAD;
  474.                    }
  475.                    break;
  476.                 }/* end switch */
  477.                }
  478.               break;
  479.             }/* end switch */
  480.         
  481.         }/* end while */
  482.  
  483.  
  484.        hdr_flag = 0; /* reinitialise for data encoding */
  485.  
  486.        while(hdr_flag != 1)/* data encoding */
  487.         {
  488.           
  489.           if(fgets(obuffer, 134, file_ptr)==NULL)
  490.            {
  491.             if (mLog)
  492.           fprintf(stderr,"\nINCORRECT DATA ENCODING SPECIFICATION\n");
  493.             ExitBAD; 
  494.            }
  495.      
  496.         len = strlen(obuffer);
  497.         obuffer[len-1] = '\0';
  498.         
  499.         buff = TrimBlanks(&obuffer[0]);
  500.  
  501.         switch (*buff)
  502.         {
  503.            case '\0':
  504.            break;
  505.            case '!':
  506.            break;
  507.            default:
  508.             {
  509.               len = StringTraverse(buff);
  510.  
  511.               if((strncmp(buff, "DATA", len) != 0)&&
  512.                  (strncmp(buff, "data", len) != 0))
  513.               {
  514.            if (mLog) {
  515.                  fprintf(stderr,"\nINCORRECT DATA ENCODING SPECIFICATION\n");
  516.                  fprintf(stderr,"%s\n", obuffer);
  517.            }
  518.                ExitBAD; 
  519.               }
  520.  
  521.               buff = buff + len;/* get past data */
  522.               buff = TrimBlanks(buff);
  523.            
  524.               if((*buff == '\0')||(*buff == '!'))/* if it ends there */
  525.                 buff = ProcessWrapLines(file_ptr, obuffer,
  526.                          "\nINCORRECT DATA ENCODING SPECIFICATION\n");
  527.  
  528.  
  529.                
  530.                if((strncmp(buff, "ENCODING", 8) != 0)&&
  531.                   (strncmp(buff, "encoding", 8) != 0))
  532.                {
  533.         if (mLog) {
  534.                   fprintf(stderr,"\nINCORRECT DATA ENCODING SPECIFICATION\n");
  535.                   fprintf(stderr,"%s\n", obuffer);
  536.         }
  537.                 ExitBAD; 
  538.                }
  539.  
  540.                buff = buff + 8;/* to get past encoding */
  541.                
  542.                buff = TrimBlanks(buff);
  543.  
  544.                if((*buff == '\0')||(*buff == '!'))
  545.                  buff = ProcessWrapLines(file_ptr, obuffer,
  546.                  "\nINCORRECT DATA ENCODING SPECIFICATION\n");
  547.  
  548.               switch(*buff)
  549.                {
  550.                 case ':':
  551.                 break;
  552.                 default:
  553.                 {
  554.           if (mLog) {
  555.                     fprintf(stderr,
  556.                 "\nINCORRECT DATA ENCODING SPECIFICATION\n");
  557.                     fprintf(stderr,"%s\n", obuffer);
  558.           }
  559.                 ExitBAD; 
  560.                 }
  561.                 break;
  562.                }/* end switch */
  563.  
  564.              buff++;/* to move past the : */
  565.  
  566.                buff = TrimBlanks(buff);
  567.  
  568.                if((*buff == '\0')||(*buff == '!'))
  569.                  buff = ProcessWrapLines(file_ptr, obuffer,
  570.                  "\nINCORRECT DATA ENCODING SPECIFICATION\n");
  571.  
  572.                   len = StringTraverse(buff);/* to reach the end */
  573.  
  574.                   encoding = (char *) malloc(len + 1);
  575.  
  576.                 *(encoding + len) = '\0';
  577.  
  578.                 strncpy(encoding, buff, len);
  579.  
  580.                  if (mLog) printf("Encoding %s\n", encoding);
  581.  
  582.                  if(strncmp(strupper(encoding), "HOST",4) == 0)
  583.                    coding = HOST_ENCODING;
  584.                  else if(strncmp(strupper(encoding), "NETWORK",7) == 0)
  585.                    coding = NETWORK_ENCODING;
  586.                  else if(strncmp(strupper(encoding), "MIPSEL",6) == 0)
  587.                    coding = MIPSEL_ENCODING;
  588.                  else if(strncmp(strupper(encoding), "MIPSEB",6) == 0)
  589.                    coding = MIPSEB_ENCODING;
  590.                  else if(strncmp(strupper(encoding), "SUN",3) == 0)
  591.                    coding = SUN_ENCODING;
  592.                  else if(strncmp(strupper(encoding), "VAX",3) == 0)
  593.            coding = VAX_ENCODING;
  594.          else if(strncmp(strupper(encoding), "IBMRS",5) == 0)
  595.            coding = IBMRS_ENCODING;
  596.          else if(strncmp(strupper(encoding), "IBMPC",5) == 0)
  597.            coding = IBMPC_ENCODING;
  598.          else if(strncmp(strupper(encoding), "HP",2) == 0)
  599.            coding = HP_ENCODING;
  600.          else
  601.            {
  602.            if (mLog) {
  603.                      fprintf(stderr,
  604.                  "\nINCORRECT DATA ENCODING SPECIFICATION\n");
  605.                      fprintf(stderr,"%s\n", obuffer);
  606.             }
  607.                     ExitBAD;
  608.                    }
  609.  
  610.                  buff = buff + len;
  611.  
  612.                  buff = TrimBlanks(buff);
  613.  
  614.                  switch(*buff)
  615.                   {
  616.                    case '\0':
  617.                      hdr_flag++;
  618.                    break;
  619.                    case '!':
  620.                      hdr_flag++;
  621.                    break;
  622.                    default:
  623.                     {
  624.              if (mLog) {
  625.                        fprintf(stderr,
  626.                 "\nINCORRECT DATA ENCODING SPECIFICATION\n");
  627.                        fprintf(stderr,"%s\n", obuffer);
  628.              }
  629.                      ExitBAD;
  630.                     }                     
  631.                    break;
  632.                   }/* end switch*/
  633.                 }
  634.            break;
  635.         }/* end switch */        
  636.        }/* end while */
  637.  
  638. /******************/
  639.        hdr_flag = 0; /* reinitialise for majority */
  640.  
  641.        while(hdr_flag != 1)/* majority*/
  642.         {
  643.           
  644.           if(fgets(obuffer, 134, file_ptr)==NULL)
  645.            {
  646.             if (mLog) fprintf(stderr,"\nINCORRECT MAJORITY SPECIFICATION\n");
  647.             ExitBAD; 
  648.            }
  649.      
  650.         len = strlen(obuffer);
  651.         *(obuffer + (len-1)) = '\0';
  652.         buff = TrimBlanks(obuffer);
  653.         switch (*buff)
  654.         {
  655.            case '\0':
  656.            break;
  657.            case '!':
  658.            break;
  659.            default:
  660.             {
  661.               len = StringTraverse(buff);
  662.  
  663.               if((strncmp(buff, "MAJORITY", 8) != 0)&&
  664.                  (strncmp(buff, "majority", 8) != 0))
  665.               {
  666.            if (mLog) {
  667.                  fprintf(stderr,"\nINCORRECT MAJORITY SPECIFICATION\n");
  668.                  fprintf(stderr,"%s\n", obuffer);
  669.            }
  670.                ExitBAD; 
  671.               }
  672.  
  673.               buff = buff + 8;/* get past majority */
  674.            
  675.  
  676.                buff = TrimBlanks(buff);
  677.  
  678.  
  679.                if((*buff == '\0')||(*buff == '!'))
  680.                  buff = ProcessWrapLines(file_ptr, obuffer,
  681.                  "\nINCORRECT MAJORITY SPECIFICATION\n");
  682.                
  683.               if(*buff != ':')
  684.               {
  685.            if (mLog) {
  686.                  fprintf(stderr,"\nINCORRECT MAJORITY SPECIFICATION\n");
  687.                  fprintf(stderr,"%s\n", obuffer);
  688.            }
  689.                ExitBAD; 
  690.               }
  691.  
  692.               buff++;/* get past the : */
  693.  
  694.               buff = TrimBlanks(buff);
  695.              
  696.               if((*buff == '\0')||(*buff == '!'))
  697.                  buff = ProcessWrapLines(file_ptr, obuffer,
  698.                  "\nINCORRECT MAJORITY SPECIFICATION\n");
  699.  
  700.                   len = StringTraverse(buff);/* to reach the end */
  701.                   majority = (char *) malloc(len + 1);
  702.  
  703.                   *(majority + len) = '\0';
  704.                   strncpy(majority, buff, len);
  705.                   if (mLog) printf("Majority %s\n", majority);
  706.                   if(strncmp(strupper(majority),"ROW", 3) == 0)
  707.                   major1 = ROW_MAJOR;
  708.                   else if (strncmp(strupper(majority),"COLUMN", 6) == 0)
  709.                   major1 = COL_MAJOR;
  710.                   else
  711.                   {
  712.             if (mLog) {
  713.                       fprintf(stderr, "\nINCORRECT MAJORITY SPECIFICATION\n");
  714.                       fprintf(stderr,"%s\n", obuffer);
  715.             }
  716.                     ExitBAD;
  717.                   }     
  718.                   buff = buff + len;
  719.  
  720.                   buff = TrimBlanks(buff);
  721.  
  722.                  switch(*buff)
  723.                   {
  724.                    case '\0':
  725.                      hdr_flag++;
  726.                    break;
  727.                    case '!':
  728.                      hdr_flag++;
  729.                    break;
  730.                    default:
  731.                     {
  732.              if (mLog) {
  733.                        fprintf(stderr,"\nINCORRECT MAJORITY SPECIFICATION\n");
  734.                        fprintf(stderr,"%s\n", obuffer);
  735.              }
  736.                      ExitBAD;
  737.                     }                     
  738.                    break;
  739.                   }/* end switch*/
  740.             }
  741.            break;
  742.         }/* end switch */        
  743.        }/* end while */
  744. /*******************/
  745.  
  746.  
  747. /******************/
  748.        hdr_flag = 0;/* reinitialise for cdf info*/
  749.  
  750.        while(hdr_flag != 1)/* CDF info*/
  751.         {
  752.            if(fgets(obuffer, 134, file_ptr)==NULL)
  753.            {
  754.             if (mLog) fprintf(stderr,"\nINCORRECT CDF INFORMATION\n");
  755.             ExitBAD; 
  756.            }
  757.      
  758.         len = strlen(obuffer);
  759.         obuffer[len-1] = '\0';
  760.         
  761.         buff = TrimBlanks(&obuffer[0]);        
  762.  
  763.          switch(*buff)
  764.            {
  765.              case '\0':
  766.                break;
  767.              case '!' :
  768.                break;
  769.              default:
  770.                    {
  771.                     hdr_flag++;
  772.                     }
  773.                 break;
  774.            }/* end switch */
  775.          }/* end while */
  776.  
  777.  
  778.        if(isdigit(*buff)== 0)/* if the 1 char encountered is not a digit */
  779.         {
  780.  
  781.         if((strncmp(buff, "FORMAT", 6) != 0)&&
  782.            (strncmp(buff, "format", 6) != 0))
  783.         {
  784.       if (mLog) {
  785.             fprintf(stderr,"\nINCORRECT FORMAT SPECIFICATION\n");
  786.             fprintf(stderr, "%s\n", obuffer);
  787.       }
  788.           ExitBAD;  
  789.         }
  790.          
  791.         buff = buff + 6;
  792.  
  793.         buff = TrimBlanks(buff);
  794.         
  795.          if((*buff == '\0')||(*buff == '!'))
  796.             buff = ProcessWrapLines(file_ptr, obuffer,
  797.             "\nINCORRECT FORMAT SPECIFICATION\n");
  798.  
  799.          if(*buff != ':')
  800.         {
  801.      if (mLog) {
  802.            fprintf(stderr,"\nINCORRECT FORMAT SPECIFICATION\n");
  803.            fprintf(stderr, "%s\n", obuffer);
  804.      }
  805.          ExitBAD;  
  806.         }
  807.  
  808.         buff++;
  809.  
  810.         buff = TrimBlanks(buff);
  811.         
  812.          if((*buff == '\0')||(*buff == '!'))
  813.             buff = ProcessWrapLines(file_ptr, obuffer,
  814.             "\nINCORRECT FORMAT SPECIFICATION\n");
  815.  
  816.          if((strncmp(buff, "SINGLE", 6)!= 0)&&(strncmp(buff, "single",6)!=0)
  817.            &&(strncmp(buff, "MULTI", 5)!= 0)&&(strncmp(buff, "multi",5)!=
  818.             0))
  819.         {
  820.       if (mLog) {
  821.             fprintf(stderr,"\nINCORRECT FORMAT SPECIFICATION\n");
  822.             fprintf(stderr, "%s\n", obuffer);
  823.       }
  824.           ExitBAD;  
  825.         }
  826.           
  827.          if((strncmp(buff, "SINGLE", 6)== 0)||(strncmp(buff, "single",6)==0))
  828.          {
  829.              buff = buff + 6;
  830.              buff = TrimBlanks(buff);
  831.              format = SINGLE_FILE;
  832.              if (mLog) printf("Format  Single File\n");
  833.          }
  834.          else
  835.          {
  836.              buff = buff + 5;
  837.              buff = TrimBlanks(buff);
  838.              format = MULTI_FILE;
  839.              if (mLog) printf("Format  Multi File\n");
  840.          }
  841.  
  842.        if((*buff != '!')&&(*buff != '\0'))
  843.         {
  844.       if (mLog) {
  845.            fprintf(stderr,"\nINCORRECT FORMAT SPECIFICATION\n");
  846.            fprintf(stderr, "%s\n", obuffer);
  847.       }
  848.           ExitBAD;  
  849.         }
  850.  
  851.        hdr_flag = 0;
  852.  
  853.  
  854.            while(hdr_flag != 1)
  855.           {
  856.              if(fgets(obuffer, 134, file_ptr) == NULL)
  857.              {
  858.               if (mLog) fprintf(stderr, "\nINCORRECT FORMAT SPECIFICATION\n");
  859.               ExitBAD;
  860.              }
  861.  
  862.             len = strlen(obuffer);
  863.             *(obuffer + (len-1)) = '\0';
  864.  
  865.             buff = TrimBlanks(obuffer);
  866.  
  867.             switch(*buff)
  868.             {
  869.                case '\0':
  870.                break;
  871.                case '!':
  872.                break;
  873.                default:
  874.                  hdr_flag++;
  875.                break;
  876.             }/* switch */
  877.           }/* end while */ 
  878.  
  879.      }/* end if */ 
  880.      else
  881.        {
  882.         format = MULTI_FILE;/* default case */            /* V1.2 */
  883.         if (mLog) printf("Format  Multi File\n");
  884.        }
  885. /***********************************/
  886.                      for (index = 0; index<= 4; index++)
  887.                      { 
  888.                        buff = TrimBlanks(buff);
  889.  
  890.                        if((*buff == '\0')||(*buff == '!'))
  891.                          buff = ProcessWrapLines(file_ptr,obuffer, 
  892.                                 "\nINCORRECT CDF INFORMATION\n");
  893.  
  894.                        if(GetValue(buff, dummy) != 0)
  895.                        {
  896.             if (mLog) {
  897.                           fprintf(stderr,"\nINCORRECT FORMAT SPECIFICATION\n");
  898.                           fprintf(stderr,"%s\n", obuffer);
  899.             }
  900.                         ExitBAD;
  901.                        }
  902.                        else
  903.                         {
  904.                           switch(index)
  905.                           {
  906.                             case 0:
  907.                                  {
  908.                                   num_vars = atoi(dummy);
  909.                                   if (mLog) printf("Variables: %ld\n", num_vars);
  910.                                   buff = buff + StringTraverse(buff);
  911.                                  }
  912.                             break;
  913.                             case 1:
  914.                                  {
  915.                                   num_gattrs = atoi(dummy);
  916.                                   if (mLog) printf("Global Attributes: %ld\n",
  917.                           num_gattrs);
  918.                                   buff = buff + StringTraverse(buff);
  919.                                  }
  920.                             break;                   
  921.                             case 2:
  922.                                  {
  923.                                   num_vattrs = atoi(dummy);
  924.                                   if (mLog) printf("Variable Attributes: %ld\n",
  925.                           num_vattrs);
  926.                                   buff = buff + StringTraverse(buff);
  927.                                  }
  928.                             break;
  929.                             case 3:
  930.                                  {
  931.                                   num_recs = atoi(dummy);
  932.                                   if (mLog) printf("Records: %ld\n", num_recs);
  933.                                   buff = buff + StringTraverse(buff);
  934.                                  }
  935.                             break;
  936.                             case 4:
  937.                                  {
  938.  
  939.                                   num_dims = atoi(dummy);
  940.  
  941.                                   if(num_dims < 0||num_dims > CDF_MAX_DIMS)
  942.                                   {
  943.                     if (mLog) {
  944.                                       fprintf(stderr,"%s",
  945.                                          "INCORRECT NUMBER OF DIMENSIONs\n" );
  946.                                       fprintf(stderr,"%s\n", obuffer);
  947.                     }
  948.                                     ExitBAD;
  949.                                   }
  950.  
  951.                                   if (mLog)
  952.                     printf("Dimensions: %ld\n", num_dims);
  953.  
  954.                                   buff = buff + StringTraverse(buff);
  955.                                  }
  956.                              default:
  957.                              break;
  958.                           }/* end switch */
  959.                         }/* end else */
  960.                      }/* end for */
  961. /******************************************************************
  962. Important - assumed that 1) All cdf info is present
  963.                          2) All the info is in one line
  964. ***************************************************************/
  965.  
  966.  
  967.                      for (index = 0; index<= num_dims - 1; index++)
  968.                      { 
  969.                        buff = TrimBlanks(buff);
  970.  
  971.                        if((*buff == '\0')||(*buff == '!'))
  972.                          buff = ProcessWrapLines(file_ptr, obuffer, 
  973.                                 "\nINCORRECT FORMAT SPECIFICATION\n");
  974.  
  975.                        if(GetValue(buff, dummy) != 0)
  976.                        {
  977.             if (mLog) {
  978.                           fprintf(stderr,"\nINCORRECT FORMAT SPECIFICATION\n");
  979.                           fprintf(stderr,"%s\n", obuffer);
  980.             }
  981.                         ExitBAD;
  982.                        }
  983.                        else
  984.                         {
  985.  
  986.                          ptr = dummy;
  987.  
  988.                          while(*ptr != '\0')
  989.                          {
  990.                            if(!isdigit(*ptr))/* if not a digit */
  991.                            {
  992.                 if (mLog) {
  993.                               fprintf(stderr, "\nINCORRECT DIMENSION SIZE\n");
  994.                               fprintf(stderr,"%s\n", obuffer);  
  995.                 }
  996.                             ExitBAD; 
  997.                            }
  998.  
  999.                           ptr++;
  1000.                          }
  1001.  
  1002.                          dim_sizes[index] = atoi(dummy);
  1003.                          if (mLog) printf("Sizes: %ld\n", dim_sizes[index]);
  1004.                          buff = buff + StringTraverse(buff);
  1005.                         }
  1006.                      }
  1007.  
  1008.        if (delete_if_exists) {
  1009.          status = CDFlib (OPEN_, CDF_, cdf_name, &id,
  1010.                     DELETE_, CDF_,
  1011.               NULL_);
  1012.      if (status != NO_SUCH_CDF) StatusHandler (status);
  1013.        }
  1014.  
  1015.        status = CDFlib (CREATE_, CDF_, cdf_name, num_dims, dim_sizes, &id,
  1016.             PUT_, CDF_ENCODING_, coding,
  1017.                   CDF_MAJORITY_, major1,
  1018.                   CDF_FORMAT_, format,
  1019.             NULL_);
  1020.        StatusHandler (status); 
  1021.  
  1022.    free(encoding);
  1023.    free(majority);
  1024.  
  1025. }
  1026.  
  1027.  
  1028. void AnalyseGlobalAttr()
  1029. {
  1030.    int hdr_flag = 0, len;
  1031.    char *buff;
  1032.  
  1033.     
  1034.       while(hdr_flag != 1)/* to first seek the "#header" */
  1035.         {
  1036.           if(fgets(obuffer, 134, file_ptr)==NULL)
  1037.            {
  1038.             if (mLog) fprintf(stderr,
  1039.                  "\nINCORRECT GLOBAL ATTRIBUTE SPECIFICATION\n");
  1040.             DeleteCDF(id);
  1041.             ExitBAD; 
  1042.            }
  1043.            
  1044.  
  1045.            len = strlen(obuffer);/* to insert in the end */
  1046.            
  1047.            obuffer[len-1] =  '\0';
  1048.  
  1049.            buff = &obuffer[0];
  1050.            
  1051.            buff = TrimBlanks(obuffer);/* get past white spaces before 
  1052.                                         the header */
  1053.  
  1054.            switch(*buff)
  1055.             {
  1056.               case '\0':
  1057.                 break;                
  1058.               case '!':
  1059.                 break;
  1060.               case '#':
  1061.                {
  1062.                  if(strncmp(buff,"#GLOBALattributes",17)==0)
  1063.                  {
  1064.                    buff = buff + 17;
  1065.                                       /* get past the above */                
  1066.                    buff = TrimBlanks(buff);
  1067.                    switch(*buff)
  1068.                    {
  1069.                     case '\0':
  1070.                      hdr_flag++;
  1071.                     break;
  1072.                     case '!':
  1073.                      hdr_flag++;
  1074.                     break;
  1075.                     default:
  1076.                     {
  1077.              if (mLog) {
  1078.                        fprintf(stderr, 
  1079.                         "\nINCORRECT GLOBAL ATTRIBUTE HEADER SPECIFICATION\n");
  1080.                        fprintf( stderr, "%s\n", obuffer);
  1081.              }
  1082.                      DeleteCDF(id);
  1083.                      ExitBAD;
  1084.                     }
  1085.                     break;
  1086.                  }/* end switch */
  1087.                 }/* end if */
  1088.                 else if (strncmp(buff,"#end",4) == 0)
  1089.                 {
  1090.                  buff = buff + 4;
  1091.                  buff = TrimBlanks(buff);  /* get past the above */                
  1092.                    switch(*buff)
  1093.                    {
  1094.                     case '\0':
  1095.                      {
  1096.                       CloseCDF(id);
  1097.                       Exit;
  1098.                      }
  1099.                     break;
  1100.                     case '!':
  1101.                      {
  1102.                       CloseCDF(id);
  1103.                       Exit;
  1104.                      }
  1105.                     break;
  1106.                     default:
  1107.                     {
  1108.              if (mLog) {
  1109.                        fprintf(stderr,
  1110.                         "\nINCORRECT GLOBAL ATTRIBUTE HEADER SPECIFICATION\n");
  1111.                        fprintf(stderr, "%s\n", obuffer);
  1112.              }
  1113.                      DeleteCDF(id);
  1114.                      ExitBAD;
  1115.                     }
  1116.                     break;
  1117.                  }/* end switch */
  1118.                 }/* end else if */
  1119.                 else
  1120.                 {
  1121.           if (mLog) {
  1122.                     fprintf(stderr,
  1123.                         "\nINCORRECT GLOBAL ATTRIBUTE HEADER SPECIFICATION\n");
  1124.                     fprintf(stderr,"%s\n", obuffer);
  1125.           }
  1126.                   DeleteCDF(id);
  1127.                   ExitBAD;
  1128.                 }/* end else */
  1129.               }        
  1130.               break;
  1131.               default:
  1132.                 {
  1133.          if (mLog) {
  1134.                    fprintf(stderr,
  1135.                       "\nINCORRECT GLOBAL ATTRIBUTE HEADER SPECIFICATION\n");
  1136.                    fprintf(stderr, "%s\n", obuffer);
  1137.          }
  1138.                  DeleteCDF(id);
  1139.                  ExitBAD;
  1140.                  }
  1141.               break;
  1142.             }/* end switch */
  1143.         } /* end while */
  1144.  
  1145.         hdr_flag = 0;
  1146.  
  1147.        while(hdr_flag != 1)/* to seek global attribute names*/
  1148.         {
  1149.           if(fgets(obuffer, 134, file_ptr)==NULL)
  1150.            {
  1151.         if (mLog) {
  1152.               fprintf(stderr,
  1153.                       "\nINCORRECT GLOBAL ATTRIBUTE SPECIFICATION\n");
  1154.               fprintf(stderr, "%s\n", obuffer);
  1155.         }
  1156.             DeleteCDF(id);
  1157.             ExitBAD; 
  1158.            }
  1159.  
  1160.            len = strlen(obuffer);/* to insert in the end */
  1161.            
  1162.            obuffer[len-1] =  '\0';
  1163.  
  1164.            buff = &obuffer[0];
  1165.            
  1166.            buff = TrimBlanks(obuffer);/* get past white spaces before 
  1167.                                         the header */
  1168.  
  1169.           
  1170.          switch(*buff)
  1171.           {
  1172.             case '\0':
  1173.             break;
  1174.             case '!':
  1175.             break;
  1176.             case '#':/* see if it is variableattribute */
  1177.             {
  1178.               if(strncmp(buff,"#VARIABLEattributes",19)==0)
  1179.                {
  1180.                  buff = buff + 19;
  1181.                  buff = TrimBlanks(buff);
  1182.                  switch(*buff)
  1183.                  {
  1184.                    case '\0':
  1185.                    hdr_flag++;/* ok */
  1186.                    break;
  1187.                    case '!':
  1188.                    hdr_flag++;/* ok */
  1189.                    break;
  1190.                    default:
  1191.                    {
  1192.             if (mLog) {
  1193.                       fprintf(stderr,
  1194.                               "\nINCORRECT GLOBAL ATTRIBUTE SPECIFICATION\n");
  1195.                       fprintf(stderr, "%s\n", obuffer);
  1196.             }
  1197.                     DeleteCDF(id);
  1198.                     ExitBAD; 
  1199.                    }
  1200.                    break;
  1201.                  }/* switch */
  1202.               }/* end if*/
  1203.               else if (strncmp(buff,"#end", 4) == 0)
  1204.               {
  1205.                 buff = buff + 4;
  1206.                 buff = TrimBlanks(buff);
  1207.                  switch(*buff)
  1208.                  {
  1209.                    case '\0':
  1210.                    {
  1211.                     CloseCDF(id);
  1212.                     Exit;
  1213.                    }
  1214.                    break;
  1215.                    case '!':
  1216.                    {
  1217.                     CloseCDF(id);
  1218.                     Exit;
  1219.                    }
  1220.                    break;
  1221.                    default:
  1222.                    {
  1223.             if (mLog) {
  1224.                       fprintf(stderr,"\nINCORRECT #END SPECIFICATION\n");
  1225.                       fprintf(stderr, "%s\n", obuffer);
  1226.             }
  1227.                     DeleteCDF(id);
  1228.                     ExitBAD; 
  1229.                    }
  1230.                    break;
  1231.                  }/* switch */
  1232.               }/* end else if */
  1233.              else/* not #globalattributes or #end */
  1234.               {
  1235.         if (mLog) {
  1236.                   fprintf(stderr,"\nINCORRECT #END SPECIFICATION\n");
  1237.                   fprintf(stderr, "%s\n", obuffer);
  1238.         }
  1239.                 DeleteCDF(id);
  1240.                 ExitBAD;
  1241.               }
  1242.             }
  1243.             break;
  1244.             default:
  1245.                { 
  1246.                 AnalyseAttrInfo(buff);
  1247.                }
  1248.             break;
  1249.           }/* end switch */    
  1250.        }/* end while */
  1251. }
  1252.  
  1253. /*-----------------------------------------------------------------*/
  1254.  
  1255. void AnalyseAttrInfo(buff)
  1256. char buff[]; 
  1257. {
  1258.   int i, len, flag = 0, hdr_flag = 0, eflag = 0, gets_flag =0,
  1259.        e_index;
  1260.  
  1261.   char attrib_name[80], data_type[80], 
  1262.         entry_num[80], *temp_addr, *dummy_ptr;
  1263.  
  1264.   
  1265. /*printf("-----------------------------------------------------\n");*/
  1266.  
  1267.     len = StringTraverse(buff);/* inclusive of delimiters */
  1268.  
  1269.  
  1270.     ParseDString(buff, *buff);/* parses the delimited string 
  1271.     puts it in str_ptr, no change to buff  */
  1272.     
  1273.     
  1274.     strcpy(attrib_name, str_ptr);/* copy from str_ptr */
  1275.  
  1276.     free(str_ptr);/* free the space for the next line */
  1277.     
  1278.     str_ptr = NULL;/* set it to null for future/recursive use */
  1279.     c_ptr = NULL;
  1280.  
  1281.      status = CDFattrCreate(id, attrib_name, GLOBAL_SCOPE, &cdf_attr_num);
  1282.      StatusHandler (status);
  1283.      
  1284.    strcpy(data_type,"");/* initialise data type for further check */
  1285.  
  1286.   while(hdr_flag == 0)
  1287.   {            /* look for information for that attribute */
  1288.  
  1289.     if(gets_flag==0)/* flag for attribute name read */
  1290.      {/* just after the attribute name is read */
  1291.       buff = buff + strlen(attrib_name) + 2;/* to get past the 
  1292.                               last delimiter - 2 for the 2 delims */
  1293.  
  1294.       buff = TrimBlanks(buff);/* to get to the entry num */    
  1295.     
  1296.       switch(*buff)/* in case nothing after that */
  1297.        {
  1298.         case '\0':
  1299.         {
  1300.            buff = ProcessWrapLines(file_ptr, obuffer,  
  1301.               "\nINCORRECT GLOBAL ATTRIBUTE SPECIFICATION\n"); 
  1302.  
  1303.          }
  1304.         break;
  1305.        case '!':
  1306.        {
  1307.            buff = ProcessWrapLines(file_ptr, obuffer,  
  1308.               "\nINCORRECT GLOBAL ATTRIBUTE SPECIFICATION\n"); 
  1309.        }
  1310.         break;
  1311.        default:
  1312.        break;   
  1313.       }/* end switch */
  1314.  
  1315.        gets_flag++;/* incrementing so that the next time read with entry num*/
  1316.      }/* end if*/
  1317.      else
  1318.      {
  1319.        
  1320.        eflag = 0;/* flag to see if any char has been reached */
  1321.        while(eflag != 1)
  1322.        {
  1323.          if(fgets(obuffer, 134, file_ptr)==NULL)
  1324.           {
  1325.         if (mLog) {
  1326.               fprintf(stderr,"\nINCORRECT GLOBAL ATTRIBUTE SPECIFICATION\n");
  1327.               fprintf(stderr, "%s\n", obuffer);
  1328.         }
  1329.             DeleteCDF(id);
  1330.             ExitBAD;
  1331.           }
  1332.  
  1333.          len = strlen(obuffer);
  1334.          obuffer[len-1] = '\0';
  1335.          buff = TrimBlanks(obuffer);
  1336.  
  1337.          switch(*buff)
  1338.          {
  1339.            case '\0':
  1340.            break;
  1341.            case '!':
  1342.            break;
  1343.            case '.':
  1344.              {
  1345.               buff++;/* get past the . */
  1346.               buff = TrimBlanks(buff);
  1347.               switch(*buff)
  1348.               {
  1349.                 case '!':
  1350.                 break;
  1351.                 case '\0':
  1352.                 break;
  1353.                 default:
  1354.                 {
  1355.          if (mLog) {
  1356.                    fprintf(stderr,
  1357.                "\nINCORRECT GLOBAL ATTRIBUTE SPECIFICATION\n");
  1358.                    fprintf(stderr, "%s\n", obuffer);
  1359.          }
  1360.                  DeleteCDF(id);
  1361.                  ExitBAD;
  1362.                 }
  1363.                 break;
  1364.               }/* end switch */
  1365.               return;/* all data for an attribute name read */
  1366.              }
  1367.            /* break; */        /* Unreachable. */
  1368.            case '#':
  1369.            {
  1370.              if(strncmp(buff,"#end",4) == 0)
  1371.              {
  1372.                buff = buff + 4;
  1373.  
  1374.               buff = TrimBlanks(buff);
  1375.          
  1376.               if((*buff == '!')||(*buff == '\0')) 
  1377.                {
  1378.                 CloseCDF(id);
  1379.                 Exit;
  1380.                }
  1381.              }
  1382.              else
  1383.              {
  1384.           if (mLog) {
  1385.                 fprintf(stderr,"\nINCORRECT GLOBAL ATTRIBUTE SPECIFICATION\n");
  1386.                 fprintf(stderr, "%s\n", obuffer);
  1387.           }
  1388.               DeleteCDF(id);
  1389.               ExitBAD;
  1390.              }
  1391.            }
  1392.            break;
  1393.            default:
  1394.              eflag++;/* get out of the loop - buff is the entry num */
  1395.          }/* end switch */
  1396.        }/* end while */
  1397.      }/* end else */
  1398.        
  1399.  
  1400.    temp_addr = buff;
  1401.     
  1402.    flag = 0;/* reinitialise in case of more than 1 entrynum */
  1403.  
  1404.     while(flag == 0)/* to read the entrynum */
  1405.      {
  1406.         switch(*buff)
  1407.          {
  1408.            case '\0':
  1409.              flag = 1;
  1410.            break;
  1411.            case '!':
  1412.              flag = 1;
  1413.            break;
  1414.            case ' ':
  1415.              flag = 1;
  1416.            break;
  1417.            case ':':
  1418.              flag = 2;
  1419.            break;
  1420.            default:
  1421.              buff++;/* otherwise increment */
  1422.            break;
  1423.          }/*end switch */
  1424.      
  1425.      }/* end while */
  1426.     
  1427.     /* if diff data  type */
  1428.  
  1429.  
  1430.  
  1431.  
  1432.      strncpy(entry_num, temp_addr, buff - temp_addr);
  1433.  
  1434.      *(entry_num + (buff - temp_addr)) = '\0';
  1435.  
  1436.      /*printf("entry_num %s\n", entry_num);*/
  1437.  
  1438.      dummy_ptr = entry_num;
  1439.  
  1440.      if(*dummy_ptr == '\0')
  1441.        {
  1442.     if (mLog) {
  1443.           fprintf(stderr, "\nINCORRECT ENTRY NUMBER SPECIFICATION\n");
  1444.           fprintf(stderr, "%s\n", obuffer);
  1445.     }
  1446.         DeleteCDF(id);
  1447.         ExitBAD;
  1448.         }
  1449.  
  1450.      while(*dummy_ptr != '\0')
  1451.      {
  1452.        if(!isdigit(*dummy_ptr))
  1453.        {
  1454.     if (mLog) {
  1455.           fprintf(stderr, "\nINCORRECT ENTRY NUMBER SPECIFICATION\n");
  1456.           fprintf(stderr, "%s\n", obuffer);
  1457.     }
  1458.         DeleteCDF(id);
  1459.         ExitBAD;
  1460.         }
  1461.         dummy_ptr++;
  1462.      }
  1463.  
  1464.      cdf_entry_num = atoi(entry_num) - 1;/* internally c style
  1465.                                         externally fortran style */
  1466.  
  1467.      e_index = 0;
  1468.  
  1469.      while(*(entry_num + e_index) != '\0') /*31 bug fix*/
  1470.        {
  1471.          *(entry_num + e_index) = ' ';
  1472.          e_index++;
  1473.        }
  1474.  
  1475.      switch(flag)
  1476.      {
  1477.        case 1:/* in case a blank space was encountered after entry_num*/
  1478.          {
  1479.  
  1480.            buff = TrimBlanks(buff);
  1481.  
  1482.            if((*buff == '\0')||(*buff == '!'))
  1483.               buff = ProcessWrapLines(file_ptr, obuffer, 
  1484.                      "\nINCORRECT GLOBAL ATTRIBUTE SPECIFICATION\n");
  1485.  
  1486.            if(*buff != ':')/* no : after entry num */
  1487.              {
  1488.           if (mLog) {
  1489.                 fprintf(stderr,
  1490.             "\nINCORRECT GLOBAL ATTRIBUTE SPECIFICATION\n");
  1491.                 fprintf(stderr, "%s\n", obuffer);
  1492.           }
  1493.               DeleteCDF(id);
  1494.               ExitBAD;
  1495.              }
  1496.  
  1497.             buff++;/* move past the : */ 
  1498.  
  1499.             buff = TrimBlanks(buff);
  1500.  
  1501.            if((*buff == '\0')||(*buff == '!'))
  1502.               buff = ProcessWrapLines(file_ptr, obuffer, 
  1503.                     "\nINCORRECT GLOBAL ATTRIBUTE SPECIFICATION\n");
  1504.  
  1505.          }/* end case 1*/
  1506.        break;
  1507.        case 2:/* in case a ':' was encountered after entry_num*/
  1508.          {
  1509.             buff++;/* move past the : */ 
  1510.  
  1511.             buff = TrimBlanks(buff);
  1512.  
  1513.            if((*buff == '\0')||(*buff == '!'))
  1514.               buff = ProcessWrapLines(file_ptr, obuffer, 
  1515.                      "\nINCORRECT GLOBAL ATTRIBUTE SPECIFICATION\n");
  1516.  
  1517.          }
  1518.        break;/* case 2 */
  1519.      }/* end switch */
  1520.   
  1521.    /* look for data type */
  1522.  
  1523.    switch(*buff)
  1524.      {
  1525.        case '{':/* if data type not previously specified */
  1526.        {
  1527.          if(strcmp(data_type,"")==0)
  1528.          {
  1529.        if (mLog) {
  1530.              fprintf(stderr,
  1531.                       "\nINCORRECT GLOBAL ATTRIBUTE SPECIFICATION\n");
  1532.              fprintf(stderr, "%s\n", obuffer);
  1533.        }
  1534.            DeleteCDF(id);
  1535.            ExitBAD;
  1536.          }
  1537.          else/* aasumes that the previous data type is valid */
  1538.          {
  1539.            /*printf("Data type: %s\n", data_type)*/;
  1540.          }
  1541.        }
  1542.        break;/* get out with buff = { */
  1543.  
  1544.        default:/* a *buff that is not \0, ! or { */
  1545.        {
  1546.         buff = ParseDataType(buff,data_type);
  1547.         cdf_data_type = AnalyseDataType(data_type);/**/ 
  1548.         /*printf("Data type: %s\n", data_type);*/
  1549.        }
  1550.        break;
  1551.      }/* end switch */
  1552.  
  1553.         buff = TrimBlanks(buff);
  1554.    
  1555.         if((*buff == '\0')||(*buff == '!'))
  1556.             buff = ProcessWrapLines(file_ptr, obuffer,
  1557.          "\nINCORRECT GLOBAL ATTRIBUTE SPECIFICATION\n");
  1558.  
  1559.         switch (*buff)/* to work on the '{' char */
  1560.         {
  1561.           case '{':
  1562.            buff++;/* get past the breace */
  1563.           break;
  1564.           default:
  1565.           {
  1566.        if (mLog) {
  1567.              fprintf(stderr,
  1568.                      "\nINCORRECTLY SPECIFIED VALUE FOR GLOBAL ATTRIBUTE\n");
  1569.              fprintf(stderr, "%s\n", obuffer);
  1570.        }
  1571.            DeleteCDF(id);
  1572.            ExitBAD;
  1573.           }
  1574.           break;
  1575.         }/* end switch */
  1576.  
  1577.  
  1578.         buff = TrimBlanks(buff);
  1579.  
  1580.  
  1581.         if((*buff == '\0')||(*buff == '!'))
  1582.             buff = ProcessWrapLines(file_ptr, obuffer,
  1583.             "\nINCORRECTLY SPECIFIED VALUE FOR GLOBAL ATTRIBUTE\n");
  1584.  
  1585.         if((cdf_data_type == CDF_CHAR)||(cdf_data_type == CDF_UCHAR))
  1586.              {
  1587.  
  1588.              hdr_flag = ParseValue(file_ptr, buff, *buff,
  1589.              "\nINCORRECTLY SPECIFIED CHARACTER VALUE FOR GLOBAL ATTRIBUTE\n");
  1590.  
  1591.               /*printf("Value: %s\n", str_ptr);*//* global pointer */
  1592.  
  1593.               status = CDFattrPut(id, cdf_attr_num, cdf_entry_num,
  1594.                     cdf_data_type, (long) strlen(str_ptr), str_ptr);
  1595.           StatusHandler (status);
  1596.  
  1597.               free(str_ptr);
  1598.               str_ptr = NULL;/* to be used when allocating recursive space */
  1599.               /*c_ptr[0] = NULL*/;
  1600.              }
  1601.             else
  1602.              {
  1603.  
  1604.               hdr_flag = ParseNumericValue(file_ptr, 
  1605.                                         buff, '}', 
  1606.               "\nINCORRECTLY SPECIFIED NUMERIC VALUE FOR GLOBAL ATTRIBUTE\n");
  1607.              /* to remove the 
  1608.               breaces, and store it in str_ptr. It stiil contains ',' and blank 
  1609.               spaces */
  1610.               /*printf("Value: %s\n", str_ptr);*//* global pointer */
  1611.  
  1612.               cdf_num_elements = ProcessNumericString();
  1613.               
  1614.               TypeConvertString(cdf_num_elements);
  1615.               /* assumed that global attributes not epoch data type */
  1616.  
  1617.               /*i= 0;
  1618.               while(*(c_ptr + i) != NULL)
  1619.                {
  1620.                  printf("Ind. Value: %s\n", *(c_ptr + i));
  1621.                  i++;
  1622.                }
  1623.                i = 0;
  1624.                while(i <= cdf_num_elements -1)
  1625.                {
  1626.                  printf("Ind. Num %d\n", *(int2_ptr + i));
  1627.                  i++;
  1628.                }*/ 
  1629.  
  1630.               switch(cdf_data_type)
  1631.               {
  1632.                case CDF_INT1:
  1633.                {
  1634.                 status = CDFattrPut(id, cdf_attr_num, cdf_entry_num,
  1635.                     cdf_data_type, cdf_num_elements, int1_ptr);
  1636.  
  1637.                   free(int1_ptr);
  1638.                } 
  1639.                break;
  1640.                case CDF_INT2:
  1641.                {
  1642.                 status = CDFattrPut(id, cdf_attr_num, cdf_entry_num,
  1643.                 cdf_data_type, cdf_num_elements, int2_ptr);
  1644.                   free(int2_ptr);
  1645.                }
  1646.                break;
  1647.                case CDF_INT4:
  1648.                {
  1649.                 status = CDFattrPut(id, cdf_attr_num, cdf_entry_num,
  1650.                     cdf_data_type, cdf_num_elements, int4_ptr);
  1651.  
  1652.                   free(int4_ptr);
  1653.                }
  1654.                break;
  1655.                case CDF_UINT1:
  1656.                {
  1657.                 status = CDFattrPut(id, cdf_attr_num, cdf_entry_num,
  1658.                     cdf_data_type, cdf_num_elements, uint1_ptr);
  1659.  
  1660.                   free(uint1_ptr);
  1661.                }
  1662.                break;
  1663.                case CDF_UINT2:
  1664.                {
  1665.                 status = CDFattrPut(id, cdf_attr_num, cdf_entry_num,
  1666.                     cdf_data_type, cdf_num_elements, uint2_ptr);
  1667.  
  1668.                   free(uint2_ptr);
  1669.  
  1670.                }
  1671.                break;
  1672.                case CDF_UINT4:
  1673.                {
  1674.                 status = CDFattrPut(id, cdf_attr_num, cdf_entry_num,
  1675.                     cdf_data_type, cdf_num_elements, uint4_ptr);
  1676.  
  1677.                   free(uint4_ptr);
  1678.                }
  1679.                break;
  1680.                case CDF_REAL4:
  1681.                {
  1682.                  status = CDFattrPut(id, cdf_attr_num, cdf_entry_num,
  1683.                     cdf_data_type, cdf_num_elements, real4_ptr);
  1684.  
  1685.                   free(real4_ptr);
  1686.                }
  1687.                break;
  1688.                case CDF_REAL8:
  1689.                {
  1690.                  status = CDFattrPut(id, cdf_attr_num, cdf_entry_num,
  1691.                     cdf_data_type, cdf_num_elements , real8_ptr);
  1692.  
  1693.                   free(real8_ptr);
  1694.                }
  1695.                break;
  1696.                case CDF_BYTE:
  1697.                {
  1698.                  status = CDFattrPut(id, cdf_attr_num, cdf_entry_num,
  1699.                     cdf_data_type, cdf_num_elements, int1_ptr);
  1700.  
  1701.  
  1702.                   free(int1_ptr);
  1703.                }
  1704.                break;
  1705.                case CDF_FLOAT:
  1706.                {
  1707.                   status = CDFattrPut(id, cdf_attr_num, cdf_entry_num,
  1708.                   cdf_data_type, cdf_num_elements, real4_ptr);
  1709.  
  1710.                   free(real4_ptr);
  1711.                }
  1712.                break;
  1713.                case CDF_DOUBLE:
  1714.                {
  1715.                  status = CDFattrPut(id, cdf_attr_num, cdf_entry_num,
  1716.                  cdf_data_type,cdf_num_elements,  real8_ptr);
  1717.  
  1718.                 free(real8_ptr);
  1719.                }
  1720.                break;
  1721.                case CDF_EPOCH:                    /* V1.1... */
  1722.                {
  1723.                  status = CDFattrPut(id, cdf_attr_num, cdf_entry_num,
  1724.                  cdf_data_type,cdf_num_elements,  real8_ptr);
  1725.  
  1726.                 free(real8_ptr);
  1727.                }
  1728.                break;                        /* ...V1.1 */
  1729.               }/* end switch */
  1730.           StatusHandler (status);
  1731.               
  1732.                i = 0;
  1733.                while(*(c_ptr + i) != NULL)/* the array of strings*/
  1734.                 {
  1735.                   dummy_ptr = (char *) *(c_ptr + i);
  1736.                   free(dummy_ptr);
  1737.                   i++;
  1738.                 }     
  1739.  
  1740.                cfree(c_ptr);
  1741.                c_ptr = NULL;
  1742.          
  1743.  
  1744.                 free(str_ptr);
  1745.               
  1746.               str_ptr = NULL;/* to be used when allocating recursive space */
  1747.  
  1748.  
  1749.     }/* end else */    
  1750.    }/* end while */
  1751. }
  1752.  
  1753.  
  1754. void AnalyseVariableAttr()
  1755. {
  1756.   int v_flag, len;
  1757.   char *buff;
  1758.   v_flag = 0;
  1759.   while(v_flag != 1)/* to seek the first variable attrname */
  1760.   {
  1761.     if(fgets(obuffer,134,file_ptr)==NULL)
  1762.     {
  1763.       if (mLog) {
  1764.         fprintf(stderr, "\nINCORRECT VARIABLE ATTRIBUTE SPECIFICATION\n");
  1765.         fprintf(stderr, "%s\n", obuffer);
  1766.       }
  1767.       DeleteCDF(id);
  1768.       ExitBAD;
  1769.     }
  1770.  
  1771.     len = strlen(obuffer);
  1772.  
  1773.     *(obuffer + (len - 1)) = '\0';
  1774.  
  1775.     buff = TrimBlanks(obuffer);
  1776.     switch(*buff)
  1777.     {
  1778.       case '\0':
  1779.       break;
  1780.       case '!':
  1781.       break;
  1782.       case '#':
  1783.       {
  1784.         if(strncmp(buff,"#variables", 10 )== 0)
  1785.         {
  1786.           buff = buff + 10;
  1787.           buff = TrimBlanks(buff);
  1788.  
  1789.           if((*buff != '\0')&&(*buff != '!'))
  1790.            {
  1791.         if (mLog) {
  1792.               fprintf(stderr,"\nINCORRECT VARIABLE ATTRIBUTE SPECIFICATION\n");
  1793.               fprintf(stderr, "%s\n", obuffer);
  1794.         }
  1795.             DeleteCDF(id);
  1796.             ExitBAD;
  1797.            }
  1798.          
  1799.            v_flag++;/* get out of the loop*/
  1800.         }
  1801.         else if (strncmp(buff,"#end",4)== 0)
  1802.         {
  1803.           buff = buff + 4;
  1804.  
  1805.           if((*buff != '\0')&&(*buff != '!'))
  1806.            {
  1807.         if (mLog) {
  1808.               fprintf(stderr,
  1809.               "\nINCORRECT VARIABLE ATTRIBUTE SPECIFICATION\n");
  1810.               fprintf(stderr, "%s\n", obuffer);
  1811.         }
  1812.             DeleteCDF(id);
  1813.             ExitBAD;
  1814.            }
  1815.           else
  1816.            {
  1817.             CloseCDF(id);
  1818.             Exit;
  1819.            }
  1820.         }/* end else if */
  1821.         else
  1822.         {
  1823.       if (mLog) {
  1824.             fprintf(stderr, "\nINCORRECT VARIABLE ATTRIBUTE SPECIFICATION\n");
  1825.             fprintf(stderr, "%s\n", obuffer);
  1826.       }
  1827.           DeleteCDF(id);
  1828.           ExitBAD;
  1829.         }/* end else */
  1830.       }
  1831.       break;
  1832.       default:
  1833.        AnalyseVattrInfo(buff);
  1834.       break;
  1835.     }/* end switch */
  1836.   }/* end while*/
  1837. }
  1838.  
  1839. /*--------------------------------------------------------------------*/
  1840.  
  1841. void AnalyseVattrInfo(buff)/* called when a delimited 
  1842.                                     string is encountered */
  1843. char buff[];
  1844. {
  1845.    char *v_attr, *temp_addr;
  1846.    int len;
  1847.  
  1848.    ParseDString(buff, *buff);/* no change to buff */
  1849.  
  1850.    len = strlen(str_ptr);
  1851.    
  1852.    v_attr = (char *)malloc(len + 1);
  1853.  
  1854.    strcpy(v_attr, str_ptr);
  1855.    *(v_attr + len) = '\0';
  1856.  
  1857.    temp_addr = buff;/* address of 1st delim */
  1858.    buff++;/* get past the 1st delim */
  1859.  
  1860.    buff = strchr(buff, *temp_addr);/* to find the address of end delim */
  1861.  
  1862.    len = (buff - temp_addr) + 1;/* length till last delim */  
  1863.    
  1864.    buff = temp_addr + len;/* get past the last delim */
  1865.  
  1866.    if((*buff != '\0')&&(*buff != '!'))/* unrec char after the delim */
  1867.     {
  1868.       if (mLog) {
  1869.         fprintf(stderr, "\nINCORRECT VARIABLE ATTRIBUTE SPECIFICATION\n\n");
  1870.         fprintf(stderr, "%s\n", obuffer);
  1871.       }
  1872.       DeleteCDF(id);
  1873.       ExitBAD;
  1874.     }
  1875.    
  1876.    status = CDFattrCreate(id, v_attr, VARIABLE_SCOPE, &cdf_attr_num);
  1877.    StatusHandler (status);
  1878.  
  1879.    free(v_attr);
  1880.    free(str_ptr);
  1881.    str_ptr = NULL;
  1882. }
  1883.  
  1884.  
  1885.  
  1886. void AnalyseVariables()/*called at the variable name point*/
  1887. {
  1888.    long hdr_flag = 0, len;
  1889.    char *buff;
  1890.  
  1891.     
  1892.     hdr_flag = 0;
  1893.  
  1894.      while(hdr_flag != 1)/* to seek variable names*/
  1895.         {
  1896.           if(fgets(obuffer, 134, file_ptr)==NULL)
  1897.            {
  1898.         if (mLog) {
  1899.               fprintf(stderr,"\nINCORRECT VARIABLE SPECIFICATION\n");
  1900.               fprintf(stderr, "%s\n", obuffer);
  1901.         }
  1902.             DeleteCDF(id);
  1903.             ExitBAD; 
  1904.            }
  1905.  
  1906.            len = strlen(obuffer);/* to insert in the end */
  1907.            
  1908.            *(obuffer + (len - 1)) =  '\0';
  1909.  
  1910.            
  1911.            buff = TrimBlanks(obuffer);/* get past white spaces before 
  1912.                                         the header */
  1913.  
  1914.           
  1915.          switch(*buff)
  1916.           {
  1917.             case '\0':
  1918.             break;
  1919.             case '!':
  1920.             break;
  1921.             case '#':/* see if it ends */
  1922.             {
  1923.               if(strncmp(buff,"#end",4)==0)
  1924.                { 
  1925.                  buff = buff + 4;
  1926.                  buff = TrimBlanks(buff);
  1927.      
  1928.                  switch(*buff)
  1929.                  {
  1930.                    case '\0':
  1931.                     hdr_flag++;/* ok */
  1932.                    break;
  1933.                    case '!':
  1934.                     hdr_flag++;/* ok */
  1935.                    break;
  1936.                    default:
  1937.                    {
  1938.              if (mLog) {
  1939.                        fprintf(stderr,"\nINCORRECT END SPECIFICATION\n");
  1940.                        fprintf(stderr, "%s\n", obuffer);
  1941.              }
  1942.                      DeleteCDF(id);
  1943.                      ExitBAD; 
  1944.                    }
  1945.                    break;
  1946.                  }/* switch */
  1947.               }/* end if */
  1948.               else
  1949.               {
  1950.         if (mLog) {
  1951.                   fprintf(stderr, "\nINCORRECT END SPECIFICATION\n");
  1952.                   fprintf(stderr, "%s\n", obuffer);
  1953.         }
  1954.                 DeleteCDF(id);
  1955.                 ExitBAD;
  1956.               }
  1957.             }
  1958.             break;
  1959.             default:
  1960.                 AnalyseVarInfo(buff);
  1961.                                     /*called when the start of the var name */
  1962.             break;
  1963.           }/* end switch */    
  1964.  
  1965.        }/* end while */
  1966.  
  1967.        CloseCDF(id);
  1968. }
  1969.  
  1970. /*------------------------------------------------------------------*/
  1971.  
  1972. void AnalyseVarInfo(buff)
  1973. char buff[];
  1974. {
  1975.   
  1976.   char *var_name, *var_data_type, *str_size, *attr_name, 
  1977.        attr_data_type[80], *dummy_ptr;
  1978.   
  1979.   long i, len, var_array[11], v_flag, eol_flag, flag, /*1 for record variance*/
  1980.       *dim_array, n_flag, a_flag;
  1981.   
  1982.   long str_len, NRV_num, dum_data_type, str_size_num;
  1983.  
  1984.   ParseDString(buff, *buff);/* parse the delimited variable name in str_ptr
  1985.                                buff remains unchanged*/
  1986.   
  1987.   var_name = (char *)malloc(strlen(str_ptr) + 1);
  1988.  
  1989.   strcpy( var_name, str_ptr);
  1990.  
  1991.   /*printf("Variable name: %s\n", var_name);*/
  1992.  
  1993.   *(var_name + (strlen(var_name))) = '\0';
  1994.  
  1995.   free(str_ptr);
  1996.  
  1997.   str_ptr = NULL;
  1998.  
  1999.   len = strlen(var_name) + 2;/* 2 for the 2 delimiters */
  2000.  
  2001.   buff = buff + len;/* get past the variable name */
  2002.  
  2003.   buff = TrimBlanks(buff);
  2004.  
  2005.   if((*buff == '\0')||(*buff == '!'))
  2006.      buff = ProcessWrapLines( file_ptr, obuffer, 
  2007.           "INCORRECT VARIABLE SPECIFICATION\n");
  2008.  
  2009.  
  2010.    len = StringTraverse(buff);
  2011.  
  2012.    var_data_type = (char *)malloc(len + 1);/* for var data type */
  2013.  
  2014.    strncpy(var_data_type, buff, len);
  2015.     
  2016.    *(var_data_type + (len)) = '\0';
  2017.    
  2018.  
  2019.    /*printf("Variable Data Type: %s\n", var_data_type);*/
  2020.  
  2021.  
  2022.     buff = buff + len;/* get past the data type */
  2023.  
  2024.  
  2025.    buff = TrimBlanks(buff);/* get to the string size */
  2026.  
  2027.  
  2028.   if((*buff == '\0')||(*buff == '!'))
  2029.      buff = ProcessWrapLines(file_ptr, obuffer, 
  2030.           "\nINCORRECT VARIABLE SPECIFICATION\n");
  2031.  
  2032.    len = StringTraverse(buff);/* the string size */
  2033.  
  2034.    str_size = (char *)malloc(len + 1);
  2035.  
  2036.    strncpy(str_size, buff, len);
  2037.  
  2038.  
  2039.    *(str_size + (len)) = '\0';
  2040.  
  2041.    /*printf("String Size: %s\n", str_size);*/
  2042.  
  2043.  
  2044.    buff = buff + len;
  2045.  
  2046.    buff = TrimBlanks(buff);
  2047.  
  2048.   if((*buff == '\0')||(*buff == '!'))
  2049.      buff = ProcessWrapLines(file_ptr, obuffer, 
  2050.           "\nINCORRECT VARIABLE SPECIFICATION\n");
  2051.  
  2052.   ParseVariances(file_ptr, buff, var_array, obuffer);
  2053.             /* assumed that all variances are in one line */
  2054.  
  2055.   dim_array = var_array;/* dim_array is an array of d. variances*/
  2056.  
  2057.     dim_array++;/* now it points to the start of the dimensions*/
  2058.  
  2059.     cdf_data_type = AnalyseDataType(var_data_type);
  2060.     
  2061.     
  2062.     if((cdf_data_type == CDF_CHAR)||(cdf_data_type == CDF_UCHAR))
  2063.       str_size_num = atoi(str_size);/* V1.3 */
  2064.     else
  2065.       str_size_num = 1;/* num_elements */
  2066.  
  2067.  
  2068.     status = CDFvarCreate(id, var_name, cdf_data_type, str_size_num,
  2069.                   *var_array, dim_array, &cdf_var_num);
  2070.     StatusHandler (status);
  2071.  
  2072.    dum_data_type = cdf_data_type;/* for nrv usage */
  2073.  
  2074.     
  2075.     /*strupper(var_name);*//* V1.3 */
  2076.  
  2077. #if 0                                /* V1.1... */
  2078.     if((strncmp(var_name,"EPOCH",5) == 0)||(strncmp(var_name,"epoch",5) == 0))
  2079.       n_flag = 1;/* to be used for epoch string conversion */
  2080.     else
  2081.       n_flag = 0;/* fixed a trouble some bug */
  2082. #endif                                /* ...V1.1 */
  2083.     n_flag = 0;                            /* V1.1? */
  2084.  
  2085.     free(var_data_type); 
  2086.     free(str_size);
  2087.  
  2088. /***********************************/
  2089.  
  2090.   strcpy(attr_data_type,"");
  2091.   v_flag = 0;/* for variable attributes */
  2092.  
  2093.   while(v_flag != 1)
  2094.   {
  2095.      flag = 0;
  2096.  
  2097.      while(flag != 1)/* to seek variable attribute names*/
  2098.         {
  2099.           if(fgets(obuffer, 134, file_ptr)==NULL)
  2100.            {
  2101.         if (mLog) {
  2102.               fprintf(stderr,"\nINCORRECT VARIABLE ATTRIBUTE SPECIFICATION\n");
  2103.               fprintf(stderr,"%s\n", obuffer);
  2104.         }
  2105.             DeleteCDF(id);
  2106.             ExitBAD; 
  2107.            }
  2108.  
  2109.            len = strlen(obuffer);/* to insert in the end */
  2110.            
  2111.            *(obuffer + (len-1)) =  '\0';
  2112.  
  2113.            
  2114.            buff = TrimBlanks(obuffer);/* get past white spaces before 
  2115.                                         the header */
  2116.  
  2117.           
  2118.          switch(*buff)
  2119.           {
  2120.             case '\0':
  2121.             break;
  2122.             case '!':
  2123.             break;
  2124.             case '.':
  2125.              {
  2126.               buff++;/* get past the */
  2127.               buff = TrimBlanks(buff);
  2128.               
  2129.               if((*buff != '!')&&(*buff != '\0'))
  2130.               {
  2131.            if (mLog) {
  2132.                  fprintf(stderr,"\nINCORRECT VARIABLE SPECIFICATION\n");
  2133.                  fprintf(stderr,"%s\n",obuffer); 
  2134.            }
  2135.                DeleteCDF(id);
  2136.                ExitBAD;               
  2137.               }
  2138.               else
  2139.               {
  2140.                 if(*var_array == NOVARY)
  2141.                   {
  2142.                     NRV_num = ComputeNRVNum(var_array, num_dims, dim_sizes);
  2143.                             /* for number of NRV values */
  2144.                    
  2145.                     if(NRV_num == 0)/* case where all dim var is false */
  2146.                       NRV_num++;/* made to 1    V1.3 */
  2147.  
  2148.                     AnalyseNRVData(NRV_num,num_dims,var_name, str_size_num);
  2149.                                   /* if nrv variable read data */
  2150.                      
  2151.                  }
  2152.                free(var_name);
  2153.                return;/* end of variable attribute data */
  2154.               }
  2155.              }
  2156.             break;
  2157.             default:
  2158.             flag++;
  2159.             break;
  2160.           }/* end switch */
  2161.     }/* end while */
  2162.  
  2163. /*printf("----------------------------------------------------------\n");*/
  2164.  
  2165.   /*len = StringTraverse(buff); */
  2166.  
  2167.   ParseDString(buff, *buff);/* buff is unchanged */
  2168.  
  2169.   str_len = strlen(str_ptr);
  2170.  
  2171.   attr_name = (char *) malloc(str_len + 1);/* cant do it in 1 step */
  2172.  
  2173.   strcpy(attr_name, str_ptr);
  2174.  
  2175.   *(attr_name +  str_len) = '\0';
  2176.  
  2177.   /*printf("Variable Attribute Value: %s\n", attr_name);*/
  2178.  
  2179.   free(str_ptr);
  2180.     len = strlen(attr_name) + 2;/* 2 for the 2 delimiters */
  2181.   
  2182.    cdf_attr_num = CDFattrNum(id, attr_name);
  2183.  
  2184.   if(cdf_attr_num < 0)/* negative */
  2185.   {
  2186.     if (mLog) {
  2187.       fprintf(stderr, "\nUNRECOGNISED ATTRIBUTE\n");
  2188.       fprintf(stderr,"%s\n",obuffer); 
  2189.     }
  2190.     DeleteCDF(id);
  2191.     ExitBAD;
  2192.   } 
  2193.    /*printf("attribute number %ld\n", cdf_attr_num);*/
  2194.  
  2195.    str_len = strlen(attr_name);
  2196.    dummy_ptr = (char *) malloc(str_len + 1);
  2197.    strcpy(dummy_ptr, attr_name);
  2198.    *(dummy_ptr + (str_len + 1)) = '\0';
  2199.    strupper(dummy_ptr);
  2200.   
  2201.    a_flag = 0;
  2202.  
  2203. #if 0                                /* V1.1... */
  2204.    if((strcmp(dummy_ptr, "VALIDMIN") == 0)||
  2205.       (strcmp(dummy_ptr, "VALIDMAX") == 0)||
  2206.       (strcmp(dummy_ptr, "SCALEMIN") == 0)||
  2207.       (strcmp(dummy_ptr, "SCALEMAX") == 0))
  2208.        a_flag = 1;
  2209. #endif                                /* ...V1.1 */
  2210.  
  2211.     free(dummy_ptr);/* not needed any more */
  2212.  
  2213.     free(attr_name);/* after creating it */
  2214.  
  2215.   buff = buff + len;/* get past the variable attr name */
  2216.  
  2217.  
  2218.   buff = TrimBlanks(buff);
  2219.  
  2220.   eol_flag = 0;
  2221.  
  2222.   switch(*buff)
  2223.    {
  2224.      case '\0':
  2225.      {
  2226.        eol_flag = 1;
  2227.      }
  2228.      break;
  2229.      case '!': 
  2230.      {
  2231.        eol_flag = 1;
  2232.      }
  2233.      break;
  2234.      default:
  2235.      break;
  2236.    }/* end switch */
  2237.  
  2238.      if(eol_flag == 1)
  2239.      {
  2240.        flag = 0;
  2241.  
  2242.        while(flag != 1)/* to seek variable attribute datatypes*/
  2243.         {
  2244.           if(fgets(obuffer, 134, file_ptr)==NULL)
  2245.            {
  2246.         if (mLog) {
  2247.               fprintf(stderr,"\nINCORRECT VARIABLE ATTRIBUTE SPECIFICATION\n");
  2248.               fprintf(stderr,"%s\n",obuffer); 
  2249.         }
  2250.             DeleteCDF(id);
  2251.             ExitBAD; 
  2252.            }
  2253.  
  2254.            len = strlen(obuffer);/* to insert in the end */
  2255.            
  2256.            *(obuffer + (len -1)) =  '\0';
  2257.  
  2258.            buff = TrimBlanks(obuffer);/* get past white spaces before */
  2259.           
  2260.          switch(*buff)
  2261.           {
  2262.             case '\0':
  2263.             break;
  2264.             case '!':
  2265.             break;
  2266.             default:
  2267.             flag++;
  2268.             break;
  2269.           }/* end switch */
  2270.        }/* end while */
  2271.      }/* end if */
  2272.  
  2273.    
  2274.                                
  2275.    if((*buff == '{')&&(strcmp(attr_data_type,"")==0))
  2276.     {
  2277.       if (mLog) {
  2278.         fprintf(stderr,"\nINCORRECT VARIABLE ATTRIBUTE SPECIFICATION\n");
  2279.         fprintf(stderr,"%s\n",obuffer); 
  2280.       }
  2281.       DeleteCDF(id);
  2282.       ExitBAD; 
  2283.     }
  2284.    else if(*buff != '{')
  2285.     {
  2286.       buff = ParseDataType(buff, attr_data_type);
  2287.  
  2288.      /*printf("Data Type: %s\n", attr_data_type);*/ 
  2289.       
  2290.       buff = TrimBlanks(buff);
  2291.      
  2292.       eol_flag = 0;
  2293.  
  2294.       switch(*buff)
  2295.       {
  2296.         case '!':
  2297.          eol_flag = 1;
  2298.         break;
  2299.         case '\0':
  2300.          eol_flag = 1;
  2301.         break;
  2302.         default:
  2303.         break;
  2304.       }/* end switch */ 
  2305.  
  2306.      if(eol_flag == 1)
  2307.      {
  2308.        flag = 0;
  2309.  
  2310.        while(flag != 1)/* to seek variable attribute datatypes*/
  2311.         {
  2312.           if(fgets(obuffer, 134, file_ptr)==NULL)
  2313.            {
  2314.         if (mLog) {
  2315.               fprintf(stderr,"\nINCORRECT VARIABLE ATTRIBUTE SPECIFICATION\n");
  2316.               fprintf(stderr,"%s\n",obuffer); 
  2317.         }
  2318.             DeleteCDF(id);
  2319.             ExitBAD; 
  2320.            }
  2321.  
  2322.            len = strlen(obuffer);/* to insert in the end */
  2323.            
  2324.            *(obuffer + (len-1)) =  '\0';
  2325.  
  2326.            
  2327.            buff = TrimBlanks(obuffer);/* get past white spaces before */
  2328.                                          
  2329.  
  2330.           
  2331.          switch(*buff)
  2332.           {
  2333.             case '\0':
  2334.             break;
  2335.             case '!':
  2336.             break;
  2337.             default:
  2338.             flag++;
  2339.             break;
  2340.           }/* end switch */
  2341.        }/* end while */
  2342.      }/* end if */     
  2343.     }/* end else if */
  2344.    else/* no data type specified */
  2345.     {
  2346.            /*printf("Data Type: %s\n", attr_data_type);*/
  2347.     }
  2348.  
  2349. /* Copy the attribute data type and check for epoch conversion */
  2350.  
  2351.  
  2352.    cdf_data_type = AnalyseDataType(attr_data_type);
  2353.  
  2354.  
  2355.    if(*buff != '{')
  2356.    {
  2357.      if (mLog) {
  2358.        fprintf(stderr,
  2359.         "\nINCORRECTLY SPECIFIED VALUE FOR VARIABLE ATTRIBUTE\n");
  2360.        fprintf(stderr,"%s\n",obuffer); 
  2361.      }
  2362.      DeleteCDF(id);
  2363.      ExitBAD;
  2364.    }
  2365.  
  2366.    buff++;/* get past the { */
  2367.  
  2368.    buff = TrimBlanks(buff);/* to eliminate spaces between */
  2369.                            /* the { and delim */
  2370.  
  2371.  
  2372.    if((*buff == '\0')||(*buff == '!')) 
  2373.    buff = ProcessWrapLines(file_ptr, obuffer, 
  2374.           "\nINCORRECTLY SPECIFIED VALUE FOR VARIABLE ATTRIBUTE\n");
  2375.  
  2376.    switch(*buff)
  2377.    {
  2378.    /*
  2379.       **********
  2380.       V2.1
  2381.       **********
  2382.      case '!':
  2383.       {
  2384.     if (mLog) {
  2385.           fprintf(stderr,
  2386.           "\nINCORRECTLY SPECIFIED VALUE FOR VARIABLE ATTRIBUTE\n");
  2387.           fprintf(stderr,"%s\n",obuffer); 
  2388.     }
  2389.         DeleteCDF(id);
  2390.         ExitBAD;
  2391.       }
  2392.     break;
  2393.     case '\0':
  2394.       {
  2395.     if (mLog) {
  2396.           fprintf(stderr,
  2397.           "\nINCORRECTLY SPECIFIED VALUE FOR VARIABLE ATTRIBUTE\n");
  2398.           fprintf(stderr,"%s\n",obuffer); 
  2399.     }
  2400.         DeleteCDF(id); 
  2401.        ExitBAD;
  2402.       }
  2403.     break; */ 
  2404.     default:
  2405.       {
  2406.         if((cdf_data_type == CDF_CHAR)||(cdf_data_type == CDF_UCHAR))
  2407.         {
  2408.           str_ptr = NULL;/* precondition for next function call */
  2409.  
  2410.           v_flag = ParseValue(file_ptr, buff, *buff,
  2411.           "\nINCORRECTLY SPECIFIED CHARACTER VALUE FOR VARIABLE ATTRIBUTE\n");
  2412.  
  2413.           /*printf("Attribute Value: %s\n", str_ptr);*/
  2414.  
  2415.           status = CDFattrPut(id, cdf_attr_num, cdf_var_num,
  2416.                    cdf_data_type, (long) strlen(str_ptr), str_ptr);
  2417.       StatusHandler (status);
  2418.  
  2419.           free(str_ptr);
  2420.           str_ptr = NULL;
  2421.           cdf_data_type = dum_data_type;/* now has the var type*/
  2422.         }
  2423.         else
  2424.         {
  2425.           str_ptr = NULL;/* precondition for next function call */
  2426.  
  2427.           v_flag = ParseNumericValue(file_ptr, buff, '}', 
  2428.           "\nINCORRECTLY SPECIFIED NUMERIC VALUE FOR GLOBAL ATTRIBUTE\n");
  2429.  
  2430.           /*printf("Attribute Value: %s\n", str_ptr);*/
  2431.  
  2432.           cdf_num_elements = ProcessNumericString();/* number of values*/
  2433.  
  2434.           if((n_flag == 1)&&(a_flag == 1))/* epoch string */
  2435.                TypeConvertString(cdf_num_elements); /* to put it the 
  2436.                          appropriate array after epoch conversion*/                    
  2437.           else
  2438.             TypeConvertString(cdf_num_elements);  /* to put it the 
  2439.                                                  appropriate array */          
  2440.               /*i= 0;
  2441.               while(*(c_ptr + i) != NULL)
  2442.                {
  2443.                  printf("Ind. Value: %s\n", *(c_ptr + i));
  2444.                  i++;
  2445.                }
  2446.                i = 0;
  2447.                while(i <= cdf_num_elements -1)
  2448.                {
  2449.                  printf("Ind. Num %d\n", *(int2_ptr + i));
  2450.                  i++;
  2451.                }*/ 
  2452.  
  2453.               switch(cdf_data_type)
  2454.               {
  2455.                case CDF_INT1:
  2456.                {
  2457.                 status = CDFattrPut(id, cdf_attr_num, cdf_var_num,
  2458.                     cdf_data_type, cdf_num_elements, int1_ptr);
  2459.  
  2460.                   free(int1_ptr);
  2461.                } 
  2462.                break;
  2463.                case CDF_INT2:
  2464.                {
  2465.                 status = CDFattrPut(id, cdf_attr_num, cdf_var_num,
  2466.                 cdf_data_type, cdf_num_elements, int2_ptr);
  2467.                  free(int2_ptr);
  2468.                }
  2469.                break;
  2470.                case CDF_INT4:
  2471.                {
  2472.  
  2473.                 status = CDFattrPut(id, cdf_attr_num, cdf_var_num,
  2474.                     cdf_data_type, cdf_num_elements, int4_ptr);
  2475.                   free(int4_ptr);
  2476.                }
  2477.                break;
  2478.                case CDF_UINT1:
  2479.                {
  2480.                 status = CDFattrPut(id, cdf_attr_num, cdf_var_num,
  2481.                     cdf_data_type, cdf_num_elements, uint1_ptr);
  2482.  
  2483.                    free(uint1_ptr);
  2484.                }
  2485.                break;
  2486.                case CDF_UINT2:
  2487.                {
  2488.                 status = CDFattrPut(id, cdf_attr_num, cdf_var_num,
  2489.                     cdf_data_type, cdf_num_elements, uint2_ptr);
  2490.  
  2491.                   free(uint2_ptr);
  2492.                }
  2493.                break;
  2494.                case CDF_UINT4:
  2495.                {
  2496.                 status = CDFattrPut(id, cdf_attr_num, cdf_var_num,
  2497.                     cdf_data_type, cdf_num_elements, uint4_ptr);
  2498.  
  2499.                   free(uint4_ptr);
  2500.                }
  2501.                break;
  2502.                case CDF_REAL4:
  2503.                {
  2504.                  status = CDFattrPut(id, cdf_attr_num, cdf_var_num,
  2505.                     cdf_data_type, cdf_num_elements, real4_ptr);
  2506.   
  2507.                   free(real4_ptr);
  2508.                }
  2509.                break;
  2510.                case CDF_REAL8:
  2511.                {
  2512.                     status = CDFattrPut(id, cdf_attr_num, cdf_var_num,
  2513.                     cdf_data_type, cdf_num_elements , real8_ptr);
  2514.  
  2515.                      free(real8_ptr);
  2516.  
  2517.                    a_flag = 0;/* for subsequent attr for the same var name */
  2518.                    /*n_flag = 0;*/
  2519.                }
  2520.                break;
  2521.                case CDF_EPOCH:                    /* V1.1... */
  2522.                {
  2523.                     status = CDFattrPut(id, cdf_attr_num, cdf_var_num,
  2524.                     cdf_data_type, cdf_num_elements , real8_ptr);
  2525.  
  2526.                      free(real8_ptr);
  2527.                }
  2528.                break;                        /* ...V1.1 */
  2529.                case CDF_BYTE:
  2530.                {
  2531.                  status = CDFattrPut(id, cdf_attr_num, cdf_var_num,
  2532.                     cdf_data_type, cdf_num_elements, int1_ptr);
  2533.  
  2534.                   free(int1_ptr);
  2535.                }
  2536.                break;
  2537.                case CDF_FLOAT:
  2538.                {
  2539.                   status = CDFattrPut(id, cdf_attr_num, cdf_var_num,
  2540.                   cdf_data_type, cdf_num_elements, real4_ptr);
  2541.  
  2542.                   free((real4_ptr));
  2543.                }
  2544.                break;
  2545.                case CDF_DOUBLE:
  2546.                {
  2547.                  status = CDFattrPut(id, cdf_attr_num, cdf_var_num,
  2548.                  cdf_data_type,cdf_num_elements,  real8_ptr);
  2549.  
  2550.                   free(real8_ptr);
  2551.                }
  2552.                break;
  2553.              }/* end switch */
  2554.          StatusHandler (status);
  2555.  
  2556.           i = 0;
  2557.           while(*(c_ptr + i) != NULL)
  2558.           {
  2559.             /*printf("Ind Value: %s\n", *(c_ptr + i));*/
  2560.             dummy_ptr = (char *) *(c_ptr + i);
  2561.             free(dummy_ptr);
  2562.             i++;
  2563.           }/* end while */
  2564.  
  2565.           cfree(c_ptr);
  2566.           c_ptr = NULL;
  2567.           
  2568.           free(str_ptr);
  2569.           str_ptr = NULL;
  2570.           
  2571.           cdf_data_type = dum_data_type;/* now has the var type*/
  2572.  
  2573.         }/* end else */
  2574.       }
  2575.     break;
  2576.    }/* end switch */
  2577.   }/* end while */
  2578.   
  2579.     if(*var_array == NOVARY)
  2580.       {
  2581.  
  2582.         NRV_num = ComputeNRVNum(var_array, num_dims, dim_sizes);
  2583.                  /* for number of NRV values */
  2584.        
  2585.         if(NRV_num == 0)/* case where all dim var is false */
  2586.             NRV_num++;/* made to 1    V1.3 */
  2587.  
  2588.           AnalyseNRVData(NRV_num, num_dims,var_name, str_size_num);
  2589.                              /* if nrv variable read data */
  2590.          
  2591.       }
  2592.      free(var_name);
  2593. }
  2594.